# -*- coding: utf-8 -*-
#!/usr/bin/env python
'''
Creado en 08/11/2009

GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
@author: Openagro
'''


import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import main_qrc
from RunWizard.RunWizard import ClassWizard 
from help import HelpWindow
import pyExcelerator as exel 


class Main_Window(QMainWindow):
    """Clase QMainWindow que implementa una instancia de la Interfaz principal"""
    
    def __init__(self, fileName=None, parent=None):
        """Metodo que inicializa la clase Main_Window"""
        QMainWindow.__init__(self, parent)
        self.init()
        

        
    def closeEvent(self, event):
        """Establece las acciones a realizar para el evento close"""
        event.accept()
        
            
    def about(self):
        """Widget de implementación para la información de Copyright"""
        QMessageBox.about(self, self.tr("Acerca de ..."),
            self.tr(u"<b>El codigo fuente asi como la ultima versión del mismo " 
            "los puede encontrar en <a href='http://openagro.appspot.com'>openagro</a>, "
                   "Este programa es GPL. Copyleft-2009</b>"))
        
    def init(self):
        """Primer metodo llamado por la interfaz Principal para inicializar componentes 
        y definir propiedades"""
        self.setWindowTitle(u'Simulación Secador')
        self.resize(400,400)
        self.central = QWidget()
        self.central.resize(398,300)
        self.setFixedWidth(400)
        self.setFixedHeight(400)
        w = self.central.width()
        h = self.central.height()
        textbrowser = QTextBrowser(self.central)
        textbrowser.resize(w,h)
        #file = open(",'rw')
        #file_read = file.read()
        file = QFile(u':/help/index.html')
        text = file.readData(1000)
        textbrowser.setHtml(text)
        self.setCentralWidget(self.central)
        self.createActions()
        self.createMenus()
        self.createToolBars()
        self.createStatusBar()
        self.readSettings()
        
    def createActions(self):
        """Define los eventos sobre la interfaz principal, asi como los shorcut de
        dichos eventos y los iconos asociados a los mismos"""
        self.closeAct = QAction(QIcon(':/images/close.png'),self.tr("&Close"), self)
        self.closeAct.setShortcut(self.tr("Ctrl+W"))
        self.closeAct.setStatusTip(self.tr(u"Cierra la aplicación"))
        self.connect(self.closeAct, SIGNAL("triggered()"), self.close)
        self.exitAct = QAction(QIcon(':/images/exit.png'),self.tr("E&xit"), self)
        self.exitAct.setShortcut(self.tr("Ctrl+Q"))
        self.exitAct.setStatusTip(self.tr(u"Cierra la aplicación"))
        self.connect(self.exitAct, SIGNAL("triggered()"), 
                     qApp.closeAllWindows)
        self.aboutAct = QAction(QIcon(':/images/about.png'),self.tr("&About"), self)
        self.aboutAct.setStatusTip(self.tr("Acerca de..."))
        self.connect(self.aboutAct, SIGNAL("triggered()"), self.about)
        
        self.helpAct = QAction(QIcon(':/images/help.png'),self.tr("&Help"), self)
        self.helpAct.setShortcut(self.tr("F1"))
        self.helpAct.setStatusTip(self.tr("Ayuda del programa..."))
        self.connect(self.helpAct, SIGNAL("triggered()"), self.help)
        
        self.runAct = QAction(QIcon(':/images/run.png'),self.tr("&Run"), self)
        self.runAct.setShortcut(self.tr("Ctrl+R"))
        self.runAct.setStatusTip(u"Empieza la resolución del problema")
        self.connect(self.runAct, SIGNAL("triggered()"), self.run)
        
        self.grafAct = QAction(QIcon(':/images/graficar.png'),self.tr("&Graficar"), self)
        self.grafAct.setShortcut(self.tr("Ctrl+G"))
        self.grafAct.setStatusTip(u"Grafica los resultados de la simulación")
        self.connect(self.grafAct, SIGNAL("triggered()"), self.graf)
        self.grafAct.setEnabled(False)
        
        self.xlsAct = QAction(QIcon(':/images/xls.png'),self.tr("&exportar xls"), self)
        self.xlsAct.setShortcut(self.tr("Ctrl+E"))
        self.xlsAct.setStatusTip(u"Exporta los resultados de la simulación")
        self.connect(self.xlsAct, SIGNAL("triggered()"), self.expXls)
        self.xlsAct.setEnabled(False)
        
        self.saveAct = QAction(QIcon(':/images/save.png'),self.tr("&Guardar"), self)
        self.saveAct.setShortcut(self.tr("Ctrl+S"))
        self.saveAct.setStatusTip(u"Guarda los resultados de la simulación")
        self.connect(self.saveAct, SIGNAL("triggered()"), self.save)
        self.saveAct.setEnabled(False)
        


    def createMenus(self):
        """Construye los menus de la barra de herramientas a partir de las acciones definidas"""
        self.fileMenu = self.menuBar().addMenu(self.tr("&Programa"))
        self.fileMenu.addAction(self.closeAct)
        self.fileMenu.addAction(self.exitAct)
        
        self.helpMenu = self.menuBar().addMenu(self.tr("&Ayuda"))
        self.helpMenu.addAction(self.aboutAct)
        self.helpMenu.addAction(self.helpAct)
        
        self.appMenu = self.menuBar().addMenu(self.tr("&Ejecutar"))
        self.appMenu.addAction(self.runAct)
        self.appMenu.addAction(self.grafAct)
        self.appMenu.addAction(self.saveAct)
        self.appMenu.addAction(self.xlsAct)

    def createToolBars(self):
        """Construye las toolbars con las acciones definidas"""
        self.fileToolBar = self.addToolBar(self.tr("File"))
        self.fileToolBar.addAction(self.exitAct)
        self.fileToolBar.addAction(self.aboutAct)
        self.fileToolBar.addAction(self.helpAct)
        
        self.editToolBar = self.addToolBar(self.tr("Edit"))
        self.editToolBar.addAction(self.runAct)
        self.editToolBar.addAction(self.grafAct)
        
        self.editToolBar.addAction(self.xlsAct)
        self.editToolBar.addAction(self.saveAct)
        
    def createStatusBar(self):
        """Construye un barra de mensajes en la parte inferior de la GUI"""
        self.statusBar().showMessage(self.tr("Ready"))
        
    def readSettings(self):
        """Establece valores del display o monitor del cliente y define su ubicación 
        dentro del mismo"""
        settings = QSettings("Dbcaturra", "Secador dos pisos")
        #pos = settings.value("pos", QVariant(QPoint(200, 200))).toPoint()
        #size = settings.value("size", QVariant(QSize(400, 400))).toSize()
        self.screen = QDesktopWidget().screenGeometry()
        size = self.geometry()
        self.move((self.screen.width()-size.width())/2, (self.screen.height()-
size.height())/2)

        #self.resize(size)
        #self.move(pos)
        
    def writeSettings(self):
        """Se establecen las propiedades definidas en readSettings()""" 
        settings = QSettings("Diego Beltran Calderón", "Secador 2 pisos")
        settings.setValue("pos", QVariant(self.pos()))
        settings.setValue("size", QVariant(self.size()))

    def createTrayIcon(self):
        """Para los sistemas que soportan TrayIcon crea un menu y un mensaje de comunicación"""
        self.trayIconMenu = QMenu(self)
        self.trayIconMenu.addAction(self.minimizeAction)
        self.trayIconMenu.addAction(self.maximizeAction)
        self.trayIconMenu.addAction(self.restoreAction)
        self.trayIconMenu.addSeparator()
        self.trayIconMenu.addAction(self.quitAction)
        self.trayIcon = QSystemTrayIcon(self)
        self.trayIcon.setContextMenu(self.trayIconMenu)
        self.trayIcon.setIcon(QIcon(":/images/run.png"))
        self.connect(self.trayIcon,
                SIGNAL("activated(QSystemTrayIcon::ActivationReason)"),
                self.iconActivated)
    

                       
    def run(self):
        """Ejecuta un widget wizard para la configuración del programa"""
        self.wizard = ClassWizard()
        self.wizard.show()

        self.saveAct.setEnabled(True)
        self.grafAct.setEnabled(True)
        self.xlsAct.setEnabled(True)

        
    def help(self):
        """Instancia el widget help: ¿Como empezar a tilizar el programa?"""
        self.helpwin = HelpWindow()
        self.helpwin.show()
        
     
    def expXls(self):
        """Función que exporta los resultados de la simulación a xls"""
        if self.wizard.flag == 1:
            fileNameXls = QFileDialog.getSaveFileName(self,
                    "Guardar los resultados de la simulación como de hoja de calculo xls",
                    ".xls")
            if fileNameXls:
                #Exporta los datos de la camara de secado
                w = exel.Workbook()
                ws = w.add_sheet(u'Salidas simulación')
                ws.write(0, 0, "T")
                ws.write(0, 1, "CHbs capa 1")
                ws.write(0, 2, "CHbs capa 2")
                ws.write(0, 3, "CHbs capa 3")
                ws.write(0, 4, "CHbs Promedio")
                lista = self.wizard.res_camSec
                lista.reverse
                for i in range(len(lista)):
                    for j in range(len(lista[0])):
                        ws.write(i+1, 0, i)
                        ws.write(i+1, j+1, lista[(len(lista)-1)-i][j])
                
                #Exporta los datos de la camara de presecado
                ws.write(0, 10, "T")
                ws.write(0, 11, "CHbs capa 1")
                ws.write(0, 12, "CHbs capa 2")
                ws.write(0, 13, "CHbs capa 3")
                ws.write(0, 14, "CHbs Promedio")
                lista = self.wizard.res_camPreSec
                lista.reverse
                for i in range(len(lista)):
                    for j in range(len(lista[0])):
                        ws.write(i+1, 10, i)
                        ws.write(i+1, j+11, lista[(len(lista)-1)-i][j])
                
    
                #Exporta los parametros iniciales del problema
                ws2 = w.add_sheet('Entradas')
                ws2.write(0, 0, 'Parametros del aire de secado')
                ws2.write(1, 1, self.wizard.caudal)
                ws2.write(2, 1, self.wizard.Tair)
                ws2.write(3, 1, self.wizard.HRair)
                
                ws2.write(1, 0, "Caudal (m3/min-m2)")
                ws2.write(2, 0, "Temperatura aire (C)")
                ws2.write(3, 0, "Humedad relativa %")
                
                ws2.write(6, 0, 'Parametros del producto')
                ws2.write(7, 1, self.wizard.Tig)
                ws2.write(8, 1, self.wizard.Hig)
                ws2.write(9, 1, self.wizard.Hfg)
                
                ws2.write(7, 0, "Temperatura del cafe pergamino (C)")
                ws2.write(8, 0, "Humedad del cafe pergamino (bh %)")
                ws2.write(9, 0, "Humedad a la salida del secador (bh %)")
                
                ws2.write(11, 0, 'Parametros del lugar')
                ws2.write(12, 1, self.wizard.msnm)
                ws2.write(13, 1, self.wizard.Tamb)
                ws2.write(12, 0, "Altura sobre el nivel del mar (msnm)")
                ws2.write(13, 0, "Temperatura ambiente (C)")
                
                ws2.write(15, 0, 'Parametros del secador')
                ws2.write(16, 1, self.wizard.STS)
                ws2.write(17, 1, self.wizard.ECG)
                ws2.write(18, 1, self.wizard.int)
                ws2.write(19, 1, self.wizard.intInv)
                ws2.write(20, 1, self.wizard.HIp)
                ws2.write(21, 1, self.wizard.TIp)
                ws2.write(22, 1, self.wizard.ECGp)
                ws2.write(16, 0, "Sección transversal (m2)")
                ws2.write(17, 0, "Espesor de la capa de grano (m)")
                ws2.write(18, 0, u"Intervalo de impresión (hr)")
                ws2.write(19, 0, u"Tiempo de inversión del flujo (hr)")
                ws2.write(20, 0, "Contenido de humedad en la camara de presecado (bh %)")
                ws2.write(21, 0, "Temperatura del cafe en la camara de presecado (C)")
                ws2.write(22, 0, "Espesor de la capa de grado en la camara de presecado (m)")
                w.save(str(fileNameXls))
                
        else:
            self.saveAct.setEnabled(False)
            self.grafAct.setEnabled(False)
            self.xlsAct.setEnabled(False)
            
            
    
    def save(self):
        """Función que guarda los resultados graficados en formato png"""
        if self.wizard.flag == 1:
            fileNameImagen = QFileDialog.getSaveFileName(self,
                    "Guardar Curvas de secado en formato de imagen png",
                    ".png")
            if fileNameImagen:
                import matplotlib.pyplot as plt
                C1=[]
                C2=[]
                C3=[]
                Cprom=[]
                
                for i in range(len(self.wizard.res_camSec)):
                    C1.insert(0,self.wizard.res_camSec[i][0])
                    C2.insert(0,self.wizard.res_camSec[i][1])
                    C3.insert(0,self.wizard.res_camSec[i][2])
                    Cprom.insert(0,self.wizard.res_camSec[i][3])
        
                tiempo = range(len(self.wizard.res_camSec))
                curvas=file("curvas.png","w")
                # plt.figure creates a matplotlib.figure.Figure instance
                plt.plot(C1, 'r-', C2,'b-', C3, 'g-',Cprom,'ys')
                plt.axis([0, len(tiempo), 0, 150])        
                plt.title(r'Curvas de secado $\mathcal{CH}_{bs}^{\%}$  vs  $t_{horas}^{secado}$',fontsize=16, color='b')
                plt.ylabel('Contenido de Humedad $\mathcal{CH}_{bs}^{\%}$',fontsize=16, color='r')
                plt.xlabel('Tiempo de secado $t_{horas}^{secado}$',fontsize=16, color='g')
                plt.savefig(str(fileNameImagen))
        else:
            self.saveAct.setEnabled(False)
            self.grafAct.setEnabled(False)
            self.xlsAct.setEnabled(False)
        
       
    def graf(self):
        """Grafica los resultados de la simulación"""
        if self.wizard.flag == 1:
            import matplotlib.pyplot as plt
            C1=[]
            C2=[]
            C3=[]
            Cprom=[]
            Cp1=[]
            Cp2=[]
            Cp3=[]
            Cpprom=[]
            
            #Organiza los datos de la camara de secado para graficar
            for i in range(len(self.wizard.res_camSec)):
                C1.insert(0,self.wizard.res_camSec[i][0])
                C2.insert(0,self.wizard.res_camSec[i][1])
                C3.insert(0,self.wizard.res_camSec[i][2])
                Cprom.insert(0,self.wizard.res_camSec[i][3])
            
            #Organiza los datos de la camara de presecado para graficar    
            for i in range(len(self.wizard.res_camPreSec)):
                Cp1.insert(0,self.wizard.res_camPreSec[i][0])
                Cp2.insert(0,self.wizard.res_camPreSec[i][1])
                Cp3.insert(0,self.wizard.res_camPreSec[i][2])
                Cpprom.insert(0,self.wizard.res_camPreSec[i][3])
    
            tiempo = range(len(self.wizard.res_camSec))
            curvas=file("curvas.png","w")
            # plt.figure creates a matplotlib.figure.Figure instance
            plt.plot(C1,'r-', C2,'b-', C3,'g-',Cprom,'y--',Cp1,'r-', Cp2,'b-',Cp3,'b-',Cpprom,'y--')
            plt.axis([0, len(self.wizard.res_camSec), 0, 150])        
            plt.title(r'Curvas de secado $\mathcal{CH}_{bs}^{\%}$  vs  $t_{horas}^{secado}$',fontsize=16, color='b')
            plt.ylabel('Contenido de Humedad $\mathcal{CH}_{bs}^{\%}$',fontsize=16, color='r')
            plt.xlabel('Tiempo de secado $t_{horas}^{secado}$',fontsize=16, color='g')
            #plt.text(20, 20, 'Curvas de secado de cafe pergamino', fontsize=20)
            plt.savefig("curvas.png",dip=0.2,transparent=False)
            png = QPixmap()
            l=png.load("curvas.png")
            self.grafLabel = QLabel()
            self.grafLabel.setPixmap(png)
            self.grafLabel.resize(980,700)
            
            #Table de resultados camara de secado
            self.table = QTableWidget()
            self.table.setColumnCount(4)
            self.table.setRowCount(len(self.wizard.res_camSec))
            headerH = [u'Chbs capa 1', u'Chbs capa 2', u'Chbs capa 3',u'Chbs promedio']
            self.table.setHorizontalHeaderLabels(headerH)
            self.table.resizeColumnsToContents()
            for k in range(len(self.wizard.res_camSec)):
                for n in range(4):
                    text="%s"%self.wizard.res_camSec[(len(self.wizard.res_camSec)-1)-k][n]
                    item = QTableWidgetItem(text)
                    item.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter)
                    self.table.setItem(k, n, item)
    
            #Table de resultados camara de secado
            self.table_p = QTableWidget()
            self.table_p.setColumnCount(4)
            self.table_p.setRowCount(len(self.wizard.res_camPreSec))
            headerH_p = [u'Chbs capa 1', u'Chbs capa 2', u'Chbs capa 3',u'Chbs promedio']
            self.table_p.setHorizontalHeaderLabels(headerH_p)
            self.table_p.resizeColumnsToContents()
            for r in range(len(self.wizard.res_camPreSec)):
                for o in range(4):
                    text_p="%s"%self.wizard.res_camPreSec[(len(self.wizard.res_camPreSec)-1)-r][o]
                    item_p = QTableWidgetItem(text_p)
                    item_p.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter)
                    self.table_p.setItem(r, o, item_p)
                
            prelabel = QLabel("Camara de Presecado")
            seclabel = QLabel("Camara de Secado")
            self.resultados = QWidget()
            self.resultados.resize(980,700)    
            layoutres = QGridLayout()
            layoutres.addWidget(seclabel,0,0)
            layoutres.addWidget(self.table,1,0)
            layoutres.addWidget(prelabel,0,1)
            layoutres.addWidget(self.table_p,1,1)
            self.resultados.setLayout(layoutres)
            
            self.tabWidget = QTabWidget()
            self.tabWidget.addTab(self.grafLabel, QIcon(':/images/graficar.png'), 'Grafica')
            self.tabWidget.addTab(self.resultados, QIcon(':/images/tabular.png'), 'Tablas')
            
            self.tabWidget.resize(980,700)
            size = self.tabWidget.geometry()
            self.tabWidget.move((self.screen.width()-size.width())/2, (self.screen.height()-
    size.height())/2)
            self.tabWidget.setWindowTitle(u'Resultados de la simulación')
            self.tabWidget.show()
            
        else:#Sino se cargaron los datos del programa desabilita las acciones de resultados, xls, graf, save.
            self.saveAct.setEnabled(False)
            self.grafAct.setEnabled(False)
            self.xlsAct.setEnabled(False) 
        
        
        
             



if __name__ == "__main__":
    """Verifica que la aplicación este ejecutandose desde un fichero y no como un
    guion sobre el interprete o consola""" 
    app = QApplication(sys.argv)
    if not QSystemTrayIcon.isSystemTrayAvailable():
        QMessageBox.critical(None, QObject.tr(app, "Systray"),
                QObject.tr(app, "I couldn't detect any system tray on "
                    "this system."))
    #app.setPalette (QPalette.Shadow)
    splash = QSplashScreen()
    splash.setPixmap(QPixmap(":/images/secado.jpg"))
    splash.show()
    import time
    time.sleep(3)
    mainwindow = Main_Window()
    mainwindow.setWindowIcon(QIcon(":/images/icono.png"))
    mainwindow.show()
    splash.finish(mainwindow)
    sys.exit(app.exec_())